COMMENT ⊗   VALID 00011 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00003 00002	ABSTRACT 				
C00005 00003	1-1  STEP BY STEP INSTRUCTIONS FOR A BASIC SOUND PROGRAM  PAGE 3-1
C00018 00004	2-1   INPUT FOR MUSIC PROGRAMS:			PAGE 4-1
C00028 00005	MUSIC COMPILER, WORD CONVERSION, AND D/A PROGRAMS:   PAGE 5-1
C00035 00006	ANALOG ASPECTS					PAGE 6
C00040 00007	MISC. FILES AND PROGRAMS 			PAGE 7-1
C00051 00008	APPENDIX NEWMUS					PAGE 8-1
C00058 00009	CHANGES, ADDITIONS, ODDS AND ENDS		PAGE 9-1
C00062 00010	A BRIEF DISCUSSION OF VARIABLES			PAGE 10-1
C00066 00011	ABRIDGED EDIT MODE COMMAND LIST				PAGE 11-1
C00071 ENDMK
C⊗;
ABSTRACT 				
LRNMUS is an information source for general music synthesis programs.
Familiarity with the Monitor Command Handbook, MUSIC.TVR[UP,DOC], and
SCORE.LCS[UP,DOC] is assumed exept for the STEP BY  STEP INSTRUCTIONS
FOR A  BASIC SOUND PROGRAM  which can  be waded through  by beginners
with  some help.   Knowledge of SAIL (or  ALGOL) is not  essential,but
strongly recomended. This file further assumes the user has access to
someone familiar with AI Lab  music programs who can fill in the gaps
which will undoubtedly exist between what  you want to know and  what
is supplied here.  This file attempts only to anticipate the broadest
questions of procedure. "Ours is not the reason why..."

Gareth Loy [ ,DGL] is the proprieter of this file.  Comments and questions
are welcome.
1-1  STEP BY STEP INSTRUCTIONS FOR A BASIC SOUND PROGRAM  PAGE 3-1
NOTE: Statements  in quotes are  computer responses to  your actions.
I've left out a lot of things in this section that might be helpful
(like how to recover from some mistakes) in the interest of coherency.
Also, changes can be expected in the programs at any time which may
not be reflected here.

This won't make any sense yet, but just remember it for later:
GENERAL OMNIBUS ERROR RECOVERY FORMULA:
	If something goes wrong after you have done the R NEWMUS command
	and are inside NEWMUS  (such as an error message, or the
	computer appears to be stuck by what you've done) you can
	save all that you have successfully loaded and continue from
	where things got wierd by doing the following: Type
<call>		
		That's the key in the upper right hand corner.
"↑C"
		You are now back to the monitor level where you were
		before you typed R NEWMUS.  Now to recover, type
S<cr>
		That is, type S then the <return_key>.
"INPUT"
		Now you are back to the first computer response after
		the R NEWMUS command, but everything the computer
		accepted from you up to the point you goofed is still
		there (such as the arrays you declaired, the 
		instrument, etc.)

       First  it  is  necessary to  connect  the  digital  to  analog
       converter (DAC or  DA) to a loudspeaker, either the four track
       facility in the music room or the monitor speaker  attached to
       your console.   The easiest  thing is  to hook up  the console
       speaker for which you type: 
<break>4U 
       This will not show up on the console.   There is a volume knob
       attached to the  speaker box, turn it to half-way.  To connect
       the 4 channel sound system, find the section on ANALOG ASPECTS
       and MONITOR  SPEAKERS on page  6, follow those  directions and
       report back here. 
	Type:
R NEWMUS<cr>
		NEWMUS is a music compiler which will take all the following
		information and from it compute the waveform and play it.
"INPUT?"
                When NEWMUS says this, it is expecting a file name.  We're
               not dealing with that yet so type:
<cr>
                (that means carriage return).  NEWMUS will type:
">"
  		O.k., now NEWMUS will accept input from your console, so
		type:
SETSPEED;
        	Note the existance and location of the semicolon. Semicolons 
		must end all declarations and statements (with exceptions as
		noted).
		SETSPEED  controls the number of channels and the speed that
		NEWMUS will compile the intrument we will write.
"number of channels:" (you type:) 1 <cr>
"sample rate:" (you type:) 25000 <cr>
"SPEED=2."
">"
 		Ready for more input so type:
ARRAY F2 (512);	

"ARRAY F2"      	
">"
               This creates an array of 512 locations numbered from 0
               to 511 in which we will store the shape of a wave used
               in our basic instrument.  The array is called F2.   F1
               is  alrea   dy  supplied  by  NEWMUS   and  is  loaded
               automatically  with numbers representing  a sine wave.
               The name F2  ("function" 2) is arbitrary.  Remember to
               put the semicolon after the declaration. 

       This  terminates the  list of  declarations  required for  our
       purposes.   There could  also be  other things here  such as  a
       VARIABLE statement,  which  just  says  that  such-and-such  a
       letter or  word,etc. exists as  a location in the  memory that
       can  store a value.  Now to  specify the shape  of the arrays,
       type: SEG(F2); You will be put into a graphic representational
       mode. 
		Type:
0 0 <cr>
                and note the result.  The first number is the amplitude
		(y axis), the second is the x axis increment at which this
		amplitude will be.  Succeeding pairs of numbers just continue
		this process until the number 100 is reached. 
1 10 <cr>
0 100 <cr>
                If after you reach 100 you type <cr>, the function will 
		display. 
                To end the display type:
0<cr>
">"
		If you want to see what the function looks like again, type:
SEE(F2);
        	When you're through, type:
0<cr>
		F1 was supplied by NEWMUS and was constructed by SYNTH,
		which operates like SEG. See pg.∀.


        Next comes the instrument definition. Type:
INSTRUMENT FUT;
OSCIL(P4,MAG/P2,F2);
OSCIL(U1,MAG*P3,F1);
OUTA←OUTA+U2;  <Note:to type the left arrow,depress the <TOP> key, 
END;           <then the "J" key,on "top" of which  lives the left arrow.
		See page 4 for an explanation of these terms.
"INSTRUMENT FUT"  
		That tells you you did everything o.k. and that FUT 
		exists as a valid instrument.

        Next comes the list of parameters which the instrument will play. 
	Type:

PLAY DA:1.0; FUT 0 1 440 1000;FINISH;		

Please note that following the DA is a colon.  The mark between  the "1.0"
is a period.
DON'T EVER LEAVE A SEMICOLON (or colon) OFF!!!
It is possilbe that you will get a message like:
"XGP in use. Wait for it to finish?"
If this happens, type:
NO<cr>

Now the  computer is gobbling  up your data  and spewing  out numbers
into  an output  file.  It  should be  left alone. This  sound seldom
takes  more  than   a  minute  to  compute.     Longer  sounds   take
proportionally more time.   You should have either  fired up the four
track setup  (as per ANALOG ASPECTS) or attached your monitor speaker
to the DA, because suddenly,  when you least expect it, a  sound well
LEAP! out at you. 

If you wish to hear it again, type:
<alt>P<cr><alt>   When you type the second <alt>, you get the sound again.

To make the sound louder, turn the volume knob to the right.

If you want to play a different note with this same instrument, rewrite the
PLAY statement using the following as a guide.
	When writing a PLAY statement directly into NEWMUS like  you are doing 
	put the entire statement on one line.  Follow the format as above
	until the first number after the word FUT.  These four numbers
	are the four parameters we have declaired in the instrument deffinition
	as P1,P2,P3 and P4.
       -The first number (P1) tells NEWMUS how long after the beginning
	of the playback the note is to sound. Since we are playing only
	one sound we want it to be 0 so we will hear it imediately.
       -The second number is the length of the note to be played.  One
 	second is recommended because the computing time is short.
	If you are experimenting, it wastes less time.  But if you want to
	change it, you must also change the number after "DA:" to match.
       -P3 is the pitch of the note.  Write either the frequency (Hz) of
	the note, or for the equal tempered tuning, a letter from A - G.
	Sharps are possible by following the letter imediately with S.
       -P4 is the volume of the note. Any value between 0 and 2047 will do.
Example of another note:
PLAY DA:5.0 FUT 0 5 AS 2000; FINISH;

You can have more than one call to an  instrument between PLAY and FINISH
blocks,as  long as you  don't call  the same instrument  to play
simultaneously with itself. If you have other instruments loaded these can be
juxtaposed in the play statement.
To leave the NEWMUS environment, type:
<alt> EXIT
"EXIT"
"↑C"
And you are back to the monitor.
2-1   INPUT FOR MUSIC PROGRAMS:			PAGE 4-1
Input is made  up of an  instrument definition, a  parameter list,and
other   information  the   compiler (NEWMUS) needs   which  we'll   call  the
initializing list. The Stanford music compiler reads this information
from one or  more files. Creating several files  for this information
is  suggested.  However,  all  the  statements  ,  declarations, etc.
described below can be  added from the console directly  into NEWMUS.
See page  3. The  advantage is flexibility  in seting things  up, the
disadvantage is that  you must then  retype the entire  event if  you
either leave  the  NEWMUS environment,  or want  to change  something
after it has been compiled. 

2-2    INITIALIZING LIST:
First, learn how to create files using the E editor. See page 11.

Create a file (maybe called INIT, or something).  Into it put the
following declarations:

SETSPEED;<# OF CHANNELS> <SAMPLING RATE>  (don't forget ;)
(typical values: SETSPEED; 1 25000). This sets the sampling rate.
	
ARRAY F2,F3,...,Fn(512);
F2,...Fn are functions (sine waves, envelope functions, etc.)
to be loaded with the instrument. (512) is the current size of a
memory block. F1 is always supplied with NEWMUS as a sine wave.
This can be overriden of course.
(Typical array statement: ARRAY F2,F3(512);)

VARIABLE <variable_name>,<v.n.>,<v.n.>;
        A number of variables
	are specified in NEWMUS automatically, such as the letters of the
	musical scale with their Hertz numbers (see APPENDIX NEWMUS).
	You can create variables for other purposes with the above format.

Other things can go into this file, for instance, you can tell
yourself the next file to read by writing:
PRINT "Next file name";
When the file is loaded into NEWMUS, the string in quotes will be printed.
Basicly you want to put everything in the initialization list
that you don't want to have to declare over and over again.


2-3    INSTRUMENT LIST
Create a file for your instrument definiton.
Now that you have arrayed the functions, specify their shape with either 
SYNTH or SEG, e.g.:

SYNTH(F2); 1 1 999 
(Note the location of the ;.)
This will create a sine wave in F2 with harmonic 1 (the fundamental) and
amplitude 1. 999 terminates the SYNTH list.  There is an extended mode:
SYNTH (F2); 99 1 1 90 1 999  
where 99 enters the mode, 
harmonic = 1, amp.=1, phase angle =90degrees, offset constant=1, 999term.

SEG(F3); 0 0 1 1 0 100 
(Note the semicolon.)
This allows  functions to  be drawn  in line  segments. The  function
described  has amplitude 0 at  location 0, amp.  1 @ loc.1,  0 @ 100.
Typing location # 100 terminates SEG.  SYNTH and SEG functions can be
created while runing NEWMUS, and will display the waveform. Just type
the above  statements up to the ";", then hit ⊂cr⊃. The waveform will
begin displaying and instructions on how to alter it will be printed.
You  can see  existing functions  graphicly in  NEWMUS by  typing SEE
(<function name>);.

Now  the instrument:
INSTRUMENT FUT;
OSCIL(P4,MAG/P2,F2);
OSCIL(U1,MAG*P3,F1);
OUTA←OUTA+U2;
END;
where: 

INSTRUMENT <name>;
begins the instrument list. This is a special kind
of DO list which the music compiler can read.  Like any DO
list,   it   must   be  terminated   by   END;   see   below.

OSCIL(<amplitude>,<frequency>,<function>);
This is a unit generator.
There are many kinds of unit generators:
see MUSIC.TVR[UP,DOC] for a complete list.

MAG
is  the magic number  specifying the  ratio of 512/sample  rate.
The  length of stored functions  in NEWMUS is 512  samples long.  The
ratio (512/sampling  rate) establishes  a base  frequency which  when
mulltiplied by  the desired frequency  number (in this  case,P3) will
sample  the  512  increment long  function  at  intervals  which will
produce the desired frequency. A further explanation  of this subject
can be found in MUSIC.TVR[UP,DOC]. This is also a good question for
a music programer. 

Pn represents a field  in an instrument call where  a number,variable
or address  can be stored to be fed  to the instrument being called. 
For instance, in the PLAY...FINISH statement, P1 is the  first number
(the number in the first field) after the name of the instrument FUT.
See  an  example  in  the  STEP  BY  STEP  INSTRUCTIONS,  and  below.
P2,P3,etc. follow after P1.   The fields are separated by  spaces (or
commas). 

Un is the output of a unit generater(numbered  in order  of  entry) 

OUTA  is  the output  block absorbing  this instrument.  There are three
more output blocks for the other three channels: OUTB, OUTC, OUTD.

END;(←note  semicolon;) this  ends the instrument list.

Comments can be added to this or any list by typing:

COMMENT say anything here until you write a semicolon , and you can 
write write as many lines as you like;
Alternate comment form:

< say anything here until a semicolon, but not exceeding one line;


2-4   INSTRUMENT WRITING CONSIDERATIONS:
Newmus is set up so  that P1 always determines the begin  time of the
instrument. For instance, if you want FUT to play at time 0, P1 would
be listed in your note list  as 0. Also, P2 is reserved to  represent
the total duration of the note  being played. So, P2 does two things:
it  tells the system  how long to  make the file  the instrument will
play into, and it also  is available to determine the length  of time
the  instrument will actually  play.   You CAN have  the instrument's
duration controled in another variable, but  P2 must still be in  the
note list  to represent the  length of the  file the  instrument will
read  into.   This information  is  given here  instead of  under the
parameter list heading below because  it affects how you define  your
instruments as well as how you write their note lists.


2-5    PARAMETER LIST
Here's where you tell the instrument what to play. 
Create a file for parameters.

PLAY;<instrument_name> P1 P2 P3 P4 ...Pn; FINISH
Typical PLAY statement for the instrument FUT described above:
PLAY FUT 0 1 440 1000;FINISH;
The parameter list must  end with FINISH;
The play statement is like a specialized block in SAIL with PLAY;
replacing BEGIN, and FINISH; for END;
Please see INSTRUMENT WRITING CONSIDERATIONS  above.
MUSIC COMPILER, WORD CONVERSION, AND D/A PROGRAMS:   PAGE 5-1
The NEWMUS compiler will be  used here.  SCORE does much  of the same
kinds of things, and is well documented in SCORE.LCS[UP,DOC]. 


3-1 NEWMUS:
	NEWMUS is a compiler, and is the vehicle by which instruments
	are coupled with their parameters.  One or more files are
	created to contain the numeric representations of the waveform.
	Type:
R NEWMUS
	After some preliminary statements, it types:
"Input:"
       Type file  names of initialization,  instrument, &  note lists
       one at a time.   When it says "Input?" it expects a file name.
       To  do  anything  else,  like  to  make   declarations,  write
       functions, or to write instruments, etc.  type ⊂cr⊃ first.  To
       return to input mode, type ⊗⊂cr⊃.  If you get an error message
       "Storage full",  type  <CALL>, and  restart  using the  FREEZE
       method,  see below. Among  the variables  that are  given with
       NEWMUS are the Hz for pitches of the equal temperament  scale:
       A:440, AS(A SHARP):466.16,...GS.  See  APPENDIX NEWMUS.  Array
       F1 is  given as a simple  sine wave.  If you  want to watch it
       compile, see MONITE[1,MUZ] below:
"Output:"
	Name a file for storage of computed samples. There should be an
	integer(or letter) extention to the file name (e.g. TEST.1). 
	This is because,if your sound file will be longer than about two
        seconds, NEWMUS will
	automatically create more files with extensions n+1 to contain it.
	"MAX AMP" is part of data printed when compilation is complete 
	used to indicate the largest sample. Remember it.
	If you have no more input, then type:
<alt> EXIT

NMUSIO:
	NMUSIO is a program which converts one or more 18 bit sound files
	as produced by NEWMUS into one long 12 bit soundfile  acceptable
	as input to the D/A converter.
	Type:
R NMUSIO
"Input:"
	Type NEWMUS output file name. If NEWMUS created more than one file
	for output (the extension is incremented one for each additional
	file created),load the files this way: <filename.ext>-<last ext>.
	For instance:FOO.1-6.
"Output:"
	Make up a storage location. Since this will be a sound file,you 
	might want to use the extension capability to identify this.
"Convert to 12 bit?"
	Y(es).  <cr> will copy input file into output without conversion.
"Max Amp:" (Write it in here, or <cr> and NMUSIO will find the figure.)
	NMUSIO then converts the files and types:
"More input?"
       If NEWMUS  had to  create more  files, you  add them here,  so
       answer Y(es); Else N(o). 
"Input:"
	Write in the additional file name and that file will be joined to the
	end of the new file.
"Finishing input?"
	Y or N. NMUSIO will CALL itself.

There is a way to avoid having to go through NMUSIO to convert 18 bit
sound files to 12 bit by setting the BYTESIZE variable in NEWMUS to the
value of 12 with a switch available.  See page 

 	The two follownig programs play the sound files through the DA.
R DSKPLY
	will explane itself. (honist!)
	This program will play sound files even if the XGP is busy.
	Set up the sound file, and continue to default  (tnat is, type
	<cr> every time) until it says GO?... then Y(es).
	To leave DSKPLY,type call, then F<cr> to make sure the XGP is 
	unhooked from your job.


For an alternate way to play sounds, type:
R MPLA to play multiple lists. TTY types:
">" (put file name here, then <cr>)
">" (if more files are to be played add them here, else just <cr> again).
"Play (O,N,X,H for help)"  type O
	Its help message is very helpful.  Type HELP to the ">".
	Leave MPLA  by doing an <alt>X, rather than a
<call> or else you will leave the XGP assigned to your job and somebody may
come looking for you...
(Question of the week, "What does the XGP have to do with the DAC, anyway?
Answer: they both are controled from the PDP 6 which is not big enough for both.
ANALOG ASPECTS					PAGE 6

4-1 Music room:
Switch  in back  of  silver  volume box  beside  Scully 280,  if  up,
moniters the  decks inside the cabinet, if  down, the Scully.  Scully
must be in record mode,  with volume up for channels outputing.   Set
Record level to about 5, Input to Line. Put Dolby in Rec mode. 

4-2 D/A:
Sampling rate of the 4 channel d/a is usually  set at 25khz, with the
corresponding low-pass filter  cutoff of 12.5khz.  If you have reason
to believe the d/a needs to be adjusted, it exists at KLUDGE BAY 2 in
the machine room.  The d/a proper  is the topmost chasis.  The bottom
most  chasis is the filter.  Switch  positions: channels 4 3 2 1  left
to right as you look at them. 

4-3 MONITOR SPEAKERS
If you  are not working  in the  music room, you  can switch the  TTY
audio channel to channel  1 of the D/A by typing BREAK 4 U (See Audio
Switch Control, 2.9, Monitor Command  Manual). BUT the D/A will  also
output to the music room,and if there are people using the D/A there,
they  will be  clobered by your  sounds. So,  send them  a message to
expect your  sounds, as it  is quite  unnerving to  be jolted out  of
meditation by another's static. See MAIL in Monitor Command.  Ttys 24
and 45 are  the ones  in the  musiic room.   Or  you might  move your
project to  the music room  to play your  sounds. Type:  AL ⊂prj,prg⊃
⊂cr⊃ to alias to a tty in the music room.  AL ⊂cr⊃ returns the tty to
its previous user. Or, DET(atch) your  job, move to an unused tty  in
the  music room  and  ATTACH  ⊂job #⊃  [prj,prg]  ⊂cr⊃.  You are  now
attached to the new tty. 
MISC. FILES AND PROGRAMS 			PAGE 7-1
**********
INFORMATION FILES:
MUSIC.TVR[UP,DOC]
SCORE.LCS[UP,DOC]
USEMUS.MAN[MAN,LCS] FOR MUSIC 10
**********

FUNC, a program for using lightpen to write functions, and/or
	to write functions into files. Lightpen works only from III's.
	Type 
R FUNC  
	After it enters, type ⊂cr⊃.  It will say
"SEG OR SYNTH?"
        Say either, usually SEG.
       When  the  graph  is displayed,  type  L  for  lightpen,  move
       lightpen  to location of  the circle  of dots, push  button on
       lightpen,  and draw.    To  fix  a  point,  hold  lightpen  at
       location, type ⊂cr⊃.  Follow directions until it says 
"ADD TO EXISTING FILE?"
	type N(o).  Then it will ask
"TYPE FILE NAME"
	write a filename without extension. Then it will say
"TYPE FUNCTION NAME"
	so write in a function name. 
	It will create the file with the extension .DAT.
	You can refrence this file from NEWMUS like any other file.
	Later, add functions to this file by saying Y(es) to 
"ADD TO EXISTING FILE?"
**********

FUNKY[MIX,MUZ] a file for manipulating arrays.
FUNKY.INF[MIX,MUZ] for information on FUNKY.
**********

WAVE[1,MUZ] a program to display samples of a sound created 
with NEWMUS.  It will not take files with extensions.  Copy the file
into a file without one, then RU WAVE[1,MUZ] and do what it says.
**********

MONITE[1,MUZ]  a file  containing  the  instrument MONITER,  used  to
display  word blocks  in NEWMUS  while they are  being computed.   It
isn't an instrument you will hear, but a kind of  visual loudspeaker.
So it's function is to display another  instrument .  So load it with
your  instrument,  and  write  a  parameter  list  for MONITER  where
P1=starting time,  P2=duration, P3 is  the amplitude,  and P4 is  how
often to display. Typical values might be 0 1 1000 2;
**********

S  This is a program, not a file, containing a display program for viewing
sound files in 12 bit and other formats.  It also contains  filters
(lowpass, hignpass). It has some internal documentation.  Type:
R S It will type:
"*"
	For information type either "?" or HELP, or see JAM. Good luck!
**********

RU CREV[MIX,MUZ] a file for creating reverb instruments. For info. type 
HELP. You want to treat the file like an automatic equation solver.  The
equation takes two supplied values  and finds the third. The variables are
Reverb_time,Gain,& Delay_time. To solve for Gain as the unknown type G,
then enter values for the other two independent variables. 
When the solution is reached, CREV will write those values into a unit
generator and put it in a file for you.  See Loren Rush for details (MUZ).
Suggested  delay factor between unit generators: .8, gain factor .94.)
Writing good reverb instruments is an intuitive gift.
**********

EGEN [GL,JAM], a file of envelope generators to be used in NEWMUS.
EGEN.INF[GL,JAM], for information on EGEN.
**********

PPSAV  This is a program, not a file, which will create a file and put into
it the contents of your screen.  The file will be called PPSAV.TMP.
**********

NOTICE: Programs and files sometimes change location.  If you are looking
for a file listed here or anywhere, and the computer doesn't find it,
try the following, type to the monitor:
DIR <filename>.<ext>[*,PRG]|[PRJ,*]
The first option will search for the file through all the programer's 
projects, the second option will search through all progects, matching
them against the filename. For example:
DIR FUNKY.INF[*,MUZ] will search MUZ for a project that has FUNKY.INF.
**********

R DRAW  -A progrram for drawing with the lightpen, or console, works only
from III consoles. Type HELP for help.
**********

To select different fonts printed on the XGP, find a font list (ask a
hacker), find one you like, then type to the monitor:
XS/NOT<file_name>/font=<font_filename>.<ext><cr>
**********

MUSIC 5 programs are located in [M5,JAM] as files PASS1.F4,PASS2.F4,PASS3.F4.
**********
APPENDIX NEWMUS					PAGE 8-1

If you  get the  error message  STORAGE FULL,  notice how large  your
current core image is, then type <call>, then increase this number by
two (or so) and type: R NEWMUS <the_number> (this specifies a minimum
core size of that number). 
**********

FREEZE METHOD:
You can add anything  to NEWMUS you want, and then  save the enlarged
version to make  it the initial form so you don't have to continually
reload the additional  data.   First add the  information to  NEWMUS,
then type:
<ALT>FREEZE 
"FROZEN!"
when frozen, exit to moniter and write
SAV <filename, anything besides NEWMUS>
Your program will be saved in the required core.  You now have a dump
file with that  filename which contains, besides NEWMUS, all the data
you have put into it.  Address it as follows:
RU <dump_file_name>
**********

EDITING FROM NEWMUS:
Given an error in an input list, you have the option to edit the
error in the file without leaving the NEWMUS environment.  Type E, the 
program then moves to the location of the error.  Correct it, then type
⊗X,then GO to return to your location in NEWMUS.
**********

Pitches given in NEWMUS:
A 	440
AS	466.16
B	493.89
C	261.62
CS	277.18
D	293.66
DS	311.13
E	329.63
F	349.23
S	369.99
G	391.99
GS	415.31
**********

If computation  is interrupetd in  NEWMUS for any  reason (such  as a
parity error,  if you type CALL accidently,  etc.) restart by typing:
RU <NEWMUS_output_file_name>.SAV <cr>.  That will  start it again  at
the point it was terminated.   If you wish to simply stop and restart
the  same  core image  at  the input  level, type  <call>,  then type
S(tart). 
**********

If you wish to see a listing of parameters introduced to NEWMUS, type
<alt>LIST<cr>	this lists all variables and arrays declared.
<alt>VARIABLE          "    "      "                    "   .
<alt>ARRAY	       "    "                  "        "   .
**********

There  is a  unit  generator in  NEWMUS  which routinizes  frequencey
modulation called INTRP.  It's parameters are:
NTRP(MAG*<minimum_modulation_index>,MAG*<max._mod._index>,<function>);
These two instruments are equivilent:
INSTRUMENT FUT;
OSCIL(P4,MAG/P2,F2);
NTRP(P5*P6*MAG,P5*P7*MAG,F3);
OSCIL(U2,P5*MAG,F1);
OSCIL(U1,MAG*P3+U3,F1);
OUTA←OUTA+U4;
END;
INSTRUMENT FUT;
OSCIL (P4,MAG/P2,F2);
OSCIL((P7-P6)*P5,MAG/P2,F3);
OSCIL((P6*P5)+U2,MAG*P5,F1);
OSCIL(U1,MAG*P3+U3,F1);
OUTA←OUTA+U4;
END;
**********

It is now possible to play sounds through the d/a as soon as they are
compiled in NEWMUS.  To do so, add the code "DA:n.n" where n is the length
of the sound file to be played in seconds (don't write integer values,the
dot is aparently necessary). This statement is placed in the PLAY statement
thus:
PLAY DA:1.0; FOO 0 1 A 1000;FINISH;  
Once the sound has played once in NEWMUS, it can be played again immediately
by typing from TTY mode:
<alt>P<cr><alt> 
and the sound will play when you type the second <alt>.
**********

You can have NEWMUS  create a 12 bit sound file  directly which saves
you from having  to run NMUSIO by typing the following when asked for
an output file name:           
"Output:"<file_name>.<ext>/SOUND/BYTESIZE=12<cr>
**********

If you are doing a long compute in NEWMUS, and you want to stop it, or it
stops itself for some reason (error, etc.) it can be restarted by the following:
RU<output_file_name>.SAV and it will start up where it left off.
Furthermore, the job that is doing the compute can be detatched from your
terminal but still continue running by doing the following:
	Start the compute
	type C↑
	type CF
**********

Within an instrument it is possible to write a statement that will be
executed only at the time the instrument is being used to generate its
waveform.  The format is:
INSTRUMENT <name>;
    I_ONLY
	<statements>
    END;
<continuation_of_instrument_list>;
END;
**********

It is possible to redefine functions from a PLAY statement.  But the
redeffinition must come AFTER! the next call to that instrument, e.g.:
PLAY; FUT 0 1 A 1000; 
FUT 1 1 C 1000; 
SEG(F2); 0 0 1 100 
FINISH;
This has the effect of redefining F2 for the second call to FUT.
The compiler calculates everything according to the latest begin time
(P1), hence, for the redeffinition to affect the next note, it must come
after the new begin time.
**********
CHANGES, ADDITIONS, ODDS AND ENDS		PAGE 9-1
USEFUL TIDBITS:
-MAG/Pn(usually pn←p2) is note duration. MAG*Pn is fqy.
-Maximum amplitude processed by the d/a = 2047.
-PRINT ⊂string⊃; will print the values, assuming they exist.
-SEE (array); will display it.
-PUT (FUNCTIONn ⊂from 0→512⊃)⊂number⊃; to change an increment in a function.
<alt>VARIABLE writen in NEWMUS will list all available variables.
<alt>FUNCTION    "    "    "     "    "    "     "     functions.
<alt>LIST will list everything indiscriminantly.
-C<space>0 will release the XGP,DA, other device attached by MPLA, etc.
-WHO<space>R | M : R=system run time display; M=your own programs.
-TO PASS NEGATIVE VALUES IN A PLAY STATEMENT, IT IS NECESSARY TO 
PRECEED THEM WITH A COMMA,otherwise the compiler wouldn't know if
it were a new peram. or an algebraic variable.
-default width of a line=69 char.
-default length of a single page = 54 char.
A BRIEF DISCUSSION OF VARIABLES			PAGE 10-1
There are two kinds of variables, regular variables, and "run-time" 
variables. 

-Just plain variables are the ones you have been dealing with so far. 
They are defined:
VARIABLE X,Y,Z;
and their values are assigned anytime after that:
x←0;
When a variable of this type is used in an instrument deffinition, it
maintains its assigned value from start to finish.

-"Run-time" variables are defined:
VARIABLE /X,/Y,/Z;
and  their  values  likewise assigned  anytime  after  that.    Their
particular  distinction is that when  they are used  in an instrument
deffinition  their  value   can  be   changed  from  one   "pushdown"
(computation of one sample of sound)  to another.  Here is an example
of a "run_time" variable:
VARIABLE /X;
X←0;
INSTRUMENT FOO;
X←X+1;
END;
If this instrument were given the following  instrument call with the
sampling rate  = 20,000, then X would equal 20,000  at the end of the
computaton: 
PLAY; FOO 0 1; FINISH;
The run_time variable will continue to increase on subsequent playing
of this instrument unless it is reassigned.  It would be 
reassigned  if either there were an assignment statement after the
PLAY statement that said so, thus:
PLAY; FOO 0 1;
X←0;
FINISH;
or if you reloaded the instrument into  the compiler (NEWMUS). In the
latter  case, you  would be  starting from  scratch and  the compiler
would see  the original assignment  statement for  that variable.  In
either  case, the  variable  would  still increment  by  1 fosxα  every
pushdown of the instrument. 

However, there  is  another place  to reassign  the  variable, and  a
reason for  doing so. In the following  instruments, the value of the
run_time variable is passed from  the first instrument to the  second
instrument.   The  purpose of  the variable  is to  pass the  current
output sample to the next instrument. If it is to be current, it must
not be cumulative.   So, at  the end of  the second instrument it  is
reset to 0. 
VARIABLE /X,/Y;
Y←X←0;
INSTRUMENT FOO;
OSCIL(P4,MAG*P3,F1);
OUTA←X←OUTA+U1;
END;
INSTRUMENT FUT;
Y←X;
X←0;
END;
ABRIDGED EDIT MODE COMMAND LIST				PAGE 11-1
	α MEANS ⊂CONTROL⊃ KEY
	β   "   ⊂META⊃    "
	⊗   "   ⊂META-CONTROL⊃
	<cr> "  ⊂RETURN⊃
	|   "   YOU HAVE A CHOICE BETWEEN WHAT`S IN THE BRACKETS
The E editor is an aid to writing files.  It supplies a list of commands 
with which files can be writen quickly and easily.  To learn the commands,
get to the monitor level, and type:
HELP ETEACH    	with a carriage return and follow instructions.

Another information source  is in E.ALS[UP,DOC] which can be addressed
either from the monitor, or while editing a file. Enter a file by typing:
ET <filename><cr> as usual, then type α? (that is, <CONTROL>?).

The following list is incomplete, possibly inaccurate, and probabily misleading.


	E EDITOR MODE COMMANDS
ET ⊂FILENAME⊃ TO EDIT A FILE
CET ⊂FILENAME⊃ TO CREATE A FILE.

	MISC.
⊂FORM⊃ KEY WINDOWS AND PAGES AUTOMATICALLY.
⊗P GOES TO NEXT PAGE
⊗W MOVES BOTTOM LINE TO TOP.
⊗J   "   CURRENT  "   "  "  .
⊗L   "   TOP      "   " BOTTOM.
⊗⊂PAGE #⊃⊗P MOVES TO THAT PAGE.
⊂alt⊃ ERASES COMMANDS.
⊂RPT⊃⊗D DELETES LINE.
⊗⊂RPT⊃C DUPLICATES A NUMBER OF LINES.
⊗Q DUPLICATES A LINE ABOVE CURRENT AND MOVES ARROW TO IT.
α⊂SPACE⊃ MOVES CURSOR TO THE RIGHT. α⊂VT⊃ MOVES IT BACK.
TY⊂FILENAME⊃ TO TYPE A FILE ON THE MONITER.
α⊂BREAK⊃ STOPS SCROLLING.
α⊂TAB⊃ MOVES CURSOR TO END OF LINE. 
α ⊂CR⊃ TO CONTINUE A PROGRAM IF YOU CUT YOURSELF OFF.

	INSERT MODE
⊗⊂CR⊃ ENTERS INSERT MODE.
α⊂CR⊃ LEAVE INSERT MODE.
⊂ALT⊃ ELIMINATES THE GAP IF NOTHING IS ENTERED ON LINE.
⊂RPT#⊃⊗⊂CR⊃ INSERTS BLANK LINES WITHOUT ENTERING INSERT MODE.

	ATTACH MODE
⊂RPT⊃|⊗F⊗R ENTERS ATTACH MODE                            
⊗E TERMINATES AND UPDATES LOCATION OF ATTACHED LINE.
⊗R RETURNS LINES TO ORIGINAL PLACE
⊗K KILLS LINES ATTACHED.
⊗E LEAVES ATTACH MODE.

	EXTEND MODE
⊗X ENTERS THE MODE.
⊗X "MARK" MOVES MATERIAL BELOW ARROW TO NEXT PAGE.
⊗X "DELETE" ELIMINATES PAGE MARK BETWEEN ONE PAGE AND THE NEXT.

	TO BREAK A LINE
⊗⊂CR⊃ BREAKS THE LINE AT CURSOR AND ENTERS INSERT MODE.
β⊂CR⊃   "    "    "   "     "   BUT NOTHING ELSE.
(α⊂CR⊃ INDICATES LINE TOO WIDE IF LINE INDENTS TO LEFT.)

	TO INSERT IN A LINE
β⊂LETTERS⊃|⊂SPACE⊃|⊂TAB⊃|⊂BS⊃.
αI TO ADD CHARACTERS IN A LINE WITHOUT HAVING TO HOLD DOWN THE β KEY.

	SEARCH MODE
⊗F⊂STATEMENT STRING⊃ FINDS THE VERBATEM STRING, COUNTS LINES TO THAT LINE,
⊗X FIND_⊂STRING⊃⊂CR⊃. SEARCHES ACROSS PAGES TO FIND THE STRING.
αS ⊂STRING⊃ MOVES CURSOR WITHIN LINE TO THE STRING LOCATION.

				******
	TV EDITOR COMMANDS
TV EDIT A FILE WITH TV.
CTV CREATE A FILE WITH TV.
⊗X "SWITCH"⊂FILENAME⊃ MOVES ATTACHED LINES TO NEW FILE.                 
				******
	TO MOVE INFORMATION BETWEEN FILES
TV ⊂File with info⊃ to locate it.
→ place cursor at top of info.
⊗F⊂bottom line of info⊃⊗A to attach info.
⊗X SWITCH ⊂filename of destination file⊃.
				******
	AIDS TO EDITING
DIR lists all files on the disk in this prj,prg.
DEL ⊂filename⊃ will delete that file.
DEL *.*[PRG,PRJ]/ASK will sequence through files asking to save or not.
α⊂CR⊃ IF THE MONITOR DIDN'T LIKE YOUR COMMAND, WILL PUT IT IN EDIT MODE.
				******
	JUSTIFYING PAGES
⊗A TO BOTTOM LINE, THEN ⊗X JU.